package com.example;

/**
 * Created by IntelliJ IDEA.
 * User: isen
 * Date: 01/02/12
 * Time: 15:45
 * To change this template use File | Settings | File Templates.
 */

public class IA {
    public static int pos(int x, int y, int hauteur, int largeur) {
        if ((x > -0 && x < largeur) && (y > -1 && y < hauteur)) {
            return (y * largeur + x);
        }
        return -1;
    }

    /**
     * VÃ©rifie si 4 pions sont alignÃ©s
     * @param symbol
     * ReprÃ©sente le joueur qui joue
     * @param ici
     * ReprÃ©sente la case oÃ¹ le joueur a jouÃ©
     * @param pas_x
     * ReprÃ©sente la direction en X que l'on veut parcourir pour trouver
     * des pions alignÃ©s
     * @param pas_y
     * ReprÃ©sente la direction en Y que l'on veut parcourir pour trouver
     * des pions alignÃ©s
     * @param game
     * ReprÃ©sente le tableau1D contenant les jetons posÃ©s
     * @param hauteur
     * ReprÃ©sente la hauteur du tableau2D
     * @param largeur
     * ReprÃ©sente la largeur du tableau2D
     * @param nb_pion
     * ReprÃ©sente le nombre de pions dÃ©jÃ  posÃ©s
     * @return
     * VRAI si 4pions de la mÃªme couleur sont alignÃ©s FAUX sinon
     */
    public static boolean aligne(int symbol, int ici, int pas_x, int pas_y, int[] game, int hauteur, int largeur, int nb_pion) {
        int somme = 0;
        int val = symbol;
        int position, y = 0;
        int nb_to_win = 4;

        int x = ici % largeur;
        if (hauteur * largeur > 1) {
            y = ((ici - x) / largeur);
        }

        for (int i = (-1 * nb_to_win) + 1; i < nb_to_win; i++) {
            position = pos(x + i * pas_x, y + i * pas_y, hauteur, largeur);
            if (position < game.length && position >= 0) {
            if(val == game[position] || ici == position) {
                somme++;
            }} else {
                somme = 0;
            }
            if (somme == nb_pion) {
                return true;
            }
        }
        return false;
    }

    /**
     *
     * @param position
     * ReprÃ©sente la position du dernier pion jouÃ© dans le tableau 1D
     * @param symbol
     * ReprÃ©sente le joueur qui a posÃ© le pion
     * @param game
     * ReprÃ©sente le jeu, c'est un tableau1D contenant les jetons des joueurs
     * @param hauteur
     * ReprÃ©sente la hauteur du tableau2D
     * @param largeur
     * ReprÃ©sente la largeur du tableau2D
     * @param nb_pion
     * ReprÃ©sente le nombre de pions dÃ©jÃ  posÃ©s
     * @return
     * Un boolean VRAI si la partie est finie, FAUX sinon
     */
    public static boolean ends(int position, int symbol, int[] game, int hauteur, int largeur, int nb_pion) {
        if (aligne(symbol, position, 1, 0, game, hauteur, largeur, nb_pion)) {
            return true;
        }
        if (aligne(symbol, position, (int) 0, (int) 1, game, hauteur, largeur, nb_pion)) {
            return true;
        }
        if (aligne(symbol, position, (int) 1, (int) 1, game, hauteur, largeur, nb_pion)) {
            return true;
        }
        if (aligne(symbol, position, 1, -1, game, hauteur, largeur, nb_pion)) {
            return true;
        }
        return false;
    }
    static int play(int symbol, int[][] tab, int lines, int cols) {

        int[] game = new int[lines*cols];
        int  id=0;
        for (int j=0;j<lines*cols;j++) game[j]=0;
        for (int y=0;y<cols;y++) {
            for (int x=0;x<lines;x++)
        {
  //          id = pos(x, y, lines, cols);
                game[id]=tab[y][x];
            id++;
            }
        }
        int stop = -1; //colonne qui bloque l'adversaire
        boolean prohib[] = new boolean[lines*cols];
        boolean toDo[] = new boolean[lines*cols];
        int where;
        int nb_to_win = 4;
        for (int i = 0; i < cols; i++) {
            prohib[i] = false;
            toDo[i] = false;
            where = (i + (lines * (cols - 1))) - 1;
            while (game[where] != 0 && where >=0) { //si on trouve un jeton Ã  l'endroit donnÃ©, on le pose au dessus
                where = where - cols;
                if (where<0) where=0;
            }
            if (ends(where, symbol, game, lines, cols, nb_to_win)) { //si on peut gagner on gagne :P
                return i;
            }
            if (ends(where, (symbol%2) +1, game, lines, cols, nb_to_win)) { //si l'adversaire peut gagner jouer ici
                stop = i;
            }
            if (ends(where - cols, symbol, game, lines, cols, nb_to_win)) { //si on gagne quand l'adversaire joue lÃ 
                if (!ends(where - 2 * cols, symbol, game, lines, cols, nb_to_win)) {
                    prohib[i] = true;
                }
            }
            if (ends(where - cols, (symbol%2) +1, game, lines, cols, nb_to_win)) { //si l'adversaire gagne parce qu'on joue au dessous de lui, ne pas jouer
                prohib[i] = true;
            }
            /*		if(ends(where, symbol, game, lines, cols, nb_to_win - 1)) { //si on peut gagner alligner 3 pions, on le fait :P
            toDo[i] = true;
            }
            if(ends(where, (symbol%2) +1, game, lines, cols, nb_to_win - 1)) { //si l'adversaire peut alligner 3 pions, on l'en empÃªche
            toDo[i] = true;
            } */
            if (stop != -1) {
                return stop;
            }
        }

        /*	for(var k; k<cols; k++) {
        if (toDo[k]) {
        return k;
        }
        } */

        int colonne;
        int antibug = 0;
        while (true) {
            colonne = (int) (Math.round(Math.random() * cols) + 1);
            where = (colonne + lines * (cols - 1)) - 1;

            if (where>-1 && where <42)
            {
                while (game[where] != 0) {
                    if(where-cols > -1) where = where - cols;

                    else where=0;

                }

            }
            if ((where > -1 && !(prohib[colonne]))) {
                return colonne;
            }
            if(antibug > 100) {
                return colonne;
            }
            antibug++;
        }
    }

}
